ระบบการพึ่งพา FastAPI: การฉีดการพึ่งพาขั้นสูง

ระบบการฉีดการพึ่งพา (DI) ของ FastAPI เป็นรากฐานสำคัญของการออกแบบ ซึ่งส่งเสริมความเป็นโมดูล, ความสามารถในการทดสอบ, และความสามารถในการนำกลับมาใช้ใหม่ แม้ว่าการใช้งานพื้นฐานจะตรงไปตรงมา แต่การเรียนรู้เทคนิค DI ขั้นสูงจะปลดล็อกพลังและความยืดหยุ่นอย่างมาก บทความนี้เจาะลึกถึงการฉีดการพึ่งพาขั้นสูงใน FastAPI ครอบคลุมการพึ่งพาที่กำหนดเอง, ขอบเขต, กลยุทธ์การทดสอบ, และแนวทางปฏิบัติที่ดีที่สุด

ทำความเข้าใจพื้นฐาน

ก่อนที่จะเจาะลึกหัวข้อขั้นสูง มาทบทวนพื้นฐานของการฉีดการพึ่งพาของ FastAPI อย่างรวดเร็ว:

• การพึ่งพาเป็นฟังก์ชัน: การพึ่งพาจะถูกประกาศเป็นฟังก์ชัน Python ทั่วไป
• การฉีดอัตโนมัติ: FastAPI จะฉีดการพึ่งพาเหล่านี้เข้าสู่การดำเนินการเส้นทางโดยอัตโนมัติตามคำแนะนำประเภท
• คำแนะนำประเภทเป็นสัญญา: คำแนะนำประเภทกำหนดประเภทอินพุตที่คาดหวังสำหรับฟังก์ชันการดำเนินการการพึ่งพาและเส้นทาง
• การพึ่งพาแบบลำดับชั้น: การพึ่งพาสามารถขึ้นอยู่กับการพึ่งพาอื่น ๆ สร้างทรีของการพึ่งพา

นี่คือตัวอย่างง่ายๆ:

            
from fastapi import FastAPI, Depends

app = FastAPI()

def get_db():
    db = {"items": []}
    try:
        yield db
    finally:
        # Close the connection if needed
        pass

@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
    return db["items"]

            

              
                Copy
              
            
          

ในตัวอย่างนี้ get_db คือการพึ่งพาที่ให้การเชื่อมต่อฐานข้อมูล FastAPI จะเรียก get_db โดยอัตโนมัติและฉีดผลลัพธ์ลงในฟังก์ชัน read_items

เทคนิคการพึ่งพาขั้นสูง

1. การใช้คลาสเป็นส่วนประกอบ

ในขณะที่ฟังก์ชันถูกใช้อย่างแพร่หลาย คลาสยังสามารถทำหน้าที่เป็นการพึ่งพาได้ ทำให้สามารถจัดการสถานะและวิธีการได้ซับซ้อนยิ่งขึ้น ซึ่งมีประโยชน์อย่างยิ่งเมื่อจัดการกับการเชื่อมต่อฐานข้อมูล บริการตรวจสอบสิทธิ์ หรือทรัพยากรอื่นๆ ที่ต้องมีการเริ่มต้นและการทำความสะอาด

            
from fastapi import FastAPI, Depends

app = FastAPI()

class Database:
    def __init__(self):
        self.connection = self.create_connection()

    def create_connection(self):
        # Simulate a database connection
        print("Creating database connection...")
        return {"items": []}

    def close(self):
        # Simulate closing a database connection
        print("Closing database connection...")

def get_db():
    db = Database()
    try:
        yield db.connection
    finally:
        db.close()

@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
    return db["items"]

            

              
                Copy
              
            
          

ในตัวอย่างนี้ คลาส Database ห่อหุ้มตรรกะการเชื่อมต่อฐานข้อมูล การพึ่งพา get_db สร้างอินสแตนซ์ของคลาส Database และให้การเชื่อมต่อ บล็อก finally ช่วยให้มั่นใจได้ว่าจะปิดการเชื่อมต่ออย่างถูกต้องหลังจากประมวลผลคำขอ

2. การแทนที่การพึ่งพา

FastAPI ช่วยให้คุณสามารถแทนที่การพึ่งพาได้ ซึ่งมีความสำคัญสำหรับการทดสอบและการพัฒนา คุณสามารถแทนที่การพึ่งพาจริงด้วยของจำลองหรือสตับเพื่อแยกโค้ดของคุณและรับประกันผลลัพธ์ที่สอดคล้องกัน

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Original dependency
def get_settings():
    # Simulate loading settings from a file or environment
    return {"api_key": "real_api_key"}

@app.get("/items/")
async def read_items(settings: dict = Depends(get_settings)):
    return {"api_key": settings["api_key"]}

# Override for testing
def get_settings_override():
    return {"api_key": "test_api_key"}

app.dependency_overrides[get_settings] = get_settings_override

# To revert back to the original:
# del app.dependency_overrides[get_settings]

            

              
                Copy
              
            
          

ในตัวอย่างนี้ การพึ่งพา get_settings ถูกแทนที่ด้วย get_settings_override ซึ่งช่วยให้คุณใช้ API key ที่แตกต่างกันเพื่อวัตถุประสงค์ในการทดสอบ

3. การใช้ `contextvars` สำหรับข้อมูลขอบเขตคำขอ

contextvars เป็นโมดูล Python ที่ให้ตัวแปรเฉพาะบริบท ซึ่งมีประโยชน์สำหรับการจัดเก็บข้อมูลเฉพาะคำขอ เช่น ข้อมูลการตรวจสอบสิทธิ์ผู้ใช้ รหัสคำขอ หรือข้อมูลการติดตาม การใช้ contextvars ร่วมกับการฉีดการพึ่งพาของ FastAPI ทำให้คุณสามารถเข้าถึงข้อมูลนี้ได้ตลอดทั้งแอปพลิเคชันของคุณ

            
import contextvars
from fastapi import FastAPI, Depends, Request

app = FastAPI()

# Create a context variable for the request ID
request_id_var = contextvars.ContextVar("request_id")

# Middleware to set the request ID
@app.middleware("http")
async def add_request_id(request: Request, call_next):
    request_id = str(uuid.uuid4())
    request_id_var.set(request_id)
    response = await call_next(request)
    response.headers["X-Request-ID"] = request_id
    return response

# Dependency to access the request ID
def get_request_id():
    return request_id_var.get()

@app.get("/items/")
async def read_items(request_id: str = Depends(get_request_id)):
    return {"request_id": request_id}

            

              
                Copy
              
            
          

ในตัวอย่างนี้ มิดเดิลแวร์ตั้งค่ารหัสคำขอที่ไม่ซ้ำกันสำหรับแต่ละคำขอที่เข้ามา การพึ่งพา get_request_id จะเรียกค้นรหัสคำขอจากบริบท contextvars ซึ่งช่วยให้คุณสามารถติดตามคำขอทั่วทั้งแอปพลิเคชันของคุณได้

4. การพึ่งพาแบบอะซิงโครนัส

FastAPI รองรับการพึ่งพาแบบอะซิงโครนัสได้อย่างราบรื่น ซึ่งจำเป็นสำหรับการดำเนินการ I/O แบบไม่บล็อก เช่น การสอบถามฐานข้อมูลหรือการเรียก API ภายนอก เพียงแค่กำหนดฟังก์ชันการพึ่งพาของคุณเป็นฟังก์ชัน async def

            
from fastapi import FastAPI, Depends
import asyncio

app = FastAPI()

async def get_data():
    # Simulate an asynchronous operation
    await asyncio.sleep(1)
    return {"message": "Hello from async dependency!"}

@app.get("/items/")
async def read_items(data: dict = Depends(get_data)):
    return data

            

              
                Copy
              
            
          

ในตัวอย่างนี้ การพึ่งพา get_data เป็นฟังก์ชันอะซิงโครนัสที่จำลองความล่าช้า FastAPI จะรอผลลัพธ์ของการพึ่งพาแบบอะซิงโครนัสโดยอัตโนมัติก่อนที่จะฉีดลงในฟังก์ชัน read_items

5. การใช้ตัวสร้างสำหรับจัดการทรัพยากร (การเชื่อมต่อฐานข้อมูล, File Handles)

การใช้ตัวสร้าง (ด้วย yield) ทำให้การจัดการทรัพยากรเป็นไปโดยอัตโนมัติ รับประกันว่าทรัพยากรจะถูกปิด/ปล่อยอย่างเหมาะสมผ่านบล็อก finally แม้ว่าข้อผิดพลาดจะเกิดขึ้น

            
from fastapi import FastAPI, Depends

app = FastAPI()


def get_file_handle():
    try:
        file_handle = open("my_file.txt", "r")
        yield file_handle
    finally:
        file_handle.close()

@app.get("/file_content/")
async def read_file_content(file_handle = Depends(get_file_handle)):
    content = file_handle.read()
    return {"content": content}

            

              
                Copy
              
            
          

ขอบเขตการพึ่งพาและวงจรชีวิต

การทำความเข้าใจขอบเขตการพึ่งพามีความสำคัญอย่างยิ่งต่อการจัดการวงจรชีวิตของการพึ่งพา และรับประกันว่ามีการจัดสรรและปล่อยทรัพยากรอย่างเหมาะสม FastAPI ไม่ได้นำเสนอคำอธิบายประกอบขอบเขตอย่างชัดเจนเหมือนเฟรมเวิร์ก DI อื่นๆ (เช่น `@RequestScope`, `@ApplicationScope` ของ Spring) แต่การรวมกันของวิธีที่คุณกำหนดการพึ่งพาและวิธีที่คุณจัดการสถานะจะให้ผลลัพธ์ที่คล้ายคลึงกัน

ขอบเขตคำขอ

นี่คือขอบเขตที่พบบ่อยที่สุด แต่ละคำขอจะได้รับอินสแตนซ์ใหม่ของการพึ่งพา โดยปกติจะทำได้โดยการสร้างวัตถุใหม่ภายในฟังก์ชันการพึ่งพาและให้ผลตอบแทนดังแสดงในตัวอย่างฐานข้อมูลก่อนหน้านี้ การใช้ contextvars ยังช่วยให้บรรลุขอบเขตคำขอได้

ขอบเขตแอปพลิเคชัน (ซิงเกิลตัน)

มีการสร้างอินสแตนซ์เดียวของการพึ่งพาและแชร์ระหว่างคำขอทั้งหมดตลอดวงจรชีวิตของแอปพลิเคชัน สิ่งนี้มักจะทำโดยใช้ตัวแปรส่วนกลางหรือแอตทริบิวต์ระดับคลาส

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Singleton instance
GLOBAL_SETTING = {"api_key": "global_api_key"}

def get_global_setting():
    return GLOBAL_SETTING

@app.get("/items/")
async def read_items(setting: dict = Depends(get_global_setting)):
    return setting

            

              
                Copy
              
            
          

โปรดใช้ความระมัดระวังเมื่อใช้การพึ่งพาในขอบเขตแอปพลิเคชันที่มีสถานะที่เปลี่ยนแปลงได้ เนื่องจากมีการเปลี่ยนแปลงโดยคำขอหนึ่งอาจส่งผลกระทบต่อคำขออื่นๆ กลไกการซิงโครไนซ์ (ล็อก ฯลฯ) อาจจำเป็นหากแอปพลิเคชันของคุณมีคำขอพร้อมกัน

ขอบเขตเซสชัน (ข้อมูลเฉพาะผู้ใช้)

เชื่อมโยงการพึ่งพากับเซสชันผู้ใช้ สิ่งนี้ต้องมีกลไกการจัดการเซสชัน (เช่น การใช้คุกกี้หรือ JWT) และโดยทั่วไปเกี่ยวข้องกับการจัดเก็บการพึ่งพาในข้อมูลเซสชัน

            
from fastapi import FastAPI, Depends, Cookie
from typing import Optional
import uuid

app = FastAPI()

# In a real app, store sessions in a database or cache
sessions = {}

async def get_user_id(session_id: Optional[str] = Cookie(None)) -> str:
    if session_id is None or session_id not in sessions:
        session_id = str(uuid.uuid4())
        sessions[session_id] = {"user_id": str(uuid.uuid4())} # Assign a random user ID
        
    return sessions[session_id]["user_id"]

@app.get("/profile/")
async def read_profile(user_id: str = Depends(get_user_id)):
    return {"user_id": user_id}

            

              
                Copy
              
            
          

การทดสอบการพึ่งพา

ประโยชน์หลักประการหนึ่งของการฉีดการพึ่งพาคือความสามารถในการทดสอบที่ดีขึ้น ด้วยการแยกส่วนประกอบ คุณสามารถแทนที่การพึ่งพาด้วยของจำลองหรือสตับได้อย่างง่ายดายในระหว่างการทดสอบ

1. การแทนที่การพึ่งพาในการทดสอบ

ดังที่แสดงก่อนหน้านี้ กลไก dependency_overrides ของ FastAPI เหมาะสำหรับการทดสอบ สร้างการพึ่งพาจำลองที่ส่งคืนผลลัพธ์ที่คาดการณ์ได้ และใช้เพื่อแยกโค้ดของคุณภายใต้การทดสอบ

            
from fastapi.testclient import TestClient
from fastapi import FastAPI, Depends

app = FastAPI()

# Original dependency
def get_external_data():
    # Simulate fetching data from an external API
    return {"data": "Real external data"}

@app.get("/data/")
async def read_data(data: dict = Depends(get_external_data)):
    return data

# Test
from unittest.mock import MagicMock

def get_external_data_mock():
    return {"data": "Mocked external data"}


def test_read_data():
    app.dependency_overrides[get_external_data] = get_external_data_mock
    client = TestClient(app)
    response = client.get("/data/")
    assert response.status_code == 200
    assert response.json() == {"data": "Mocked external data"}

    # Clean up overrides
    app.dependency_overrides.clear()


            

              
                Copy
              
            
          

2. การใช้ไลบรารีจำลอง

ไลบรารีเช่น unittest.mock ให้เครื่องมืออันทรงพลังสำหรับการสร้างวัตถุจำลองและควบคุมพฤติกรรมของวัตถุเหล่านั้น คุณสามารถใช้ของจำลองเพื่อจำลองการพึ่งพาที่ซับซ้อนและตรวจสอบว่าโค้ดของคุณโต้ตอบกับสิ่งเหล่านั้นอย่างถูกต้อง

            
import unittest
from unittest.mock import MagicMock

# (Define the FastAPI app and get_external_data as above)

class TestReadData(unittest.TestCase):
    def test_read_data_with_mock(self):
        # Create a mock for the get_external_data dependency
        mock_get_external_data = MagicMock(return_value={"data": "Mocked data from unittest"})

        # Override the dependency with the mock
        app.dependency_overrides[get_external_data] = mock_get_external_data

        client = TestClient(app)
        response = client.get("/data/")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"data": "Mocked data from unittest"})

        # Assert that the mock was called
        mock_get_external_data.assert_called_once()

        # Clean up overrides
        app.dependency_overrides.clear()

            

              
                Copy
              
            
          

3. การฉีดการพึ่งพาสำหรับการทดสอบหน่วย (ภายนอกบริบท FastAPI)

แม้ในขณะที่ทดสอบหน่วยฟังก์ชัน *ภายนอก* ตัวจัดการจุดสิ้นสุด API หลักการฉีดการพึ่งพายังคงใช้ได้ แทนที่จะอาศัย `Depends` ของ FastAPI ให้ฉีดการพึ่งพาลงในฟังก์ชันภายใต้การทดสอบด้วยตนเอง

            
# Example function to test
def process_data(data_source):
    data = data_source.fetch_data()
    # ... process the data ...
    return processed_data

class MockDataSource:
    def fetch_data(self):
        return {"example": "data"}

# Unit test
def test_process_data():
    mock_data_source = MockDataSource()
    result = process_data(mock_data_source)
    # Assertions on the result

            

              
                Copy
              
            
          

ข้อควรพิจารณาด้านความปลอดภัยด้วยการฉีดการพึ่งพา

การฉีดการพึ่งพา แม้ว่าจะเป็นประโยชน์ แต่ก็ทำให้เกิดข้อกังวลด้านความปลอดภัยหากไม่ได้ดำเนินการอย่างรอบคอบ

1. ความสับสนในการพึ่งพา

ตรวจสอบให้แน่ใจว่าคุณกำลังดึงการพึ่งพาจากแหล่งที่เชื่อถือได้ ตรวจสอบความสมบูรณ์ของแพ็กเกจและใช้ตัวจัดการแพ็กเกจที่มีความสามารถในการสแกนช่องโหว่ นี่เป็นหลักการด้านความปลอดภัยของห่วงโซ่อุปทานซอฟต์แวร์ทั่วไป แต่ได้รับการกระตุ้นโดย DI เนื่องจากคุณอาจกำลังฉีดส่วนประกอบจากแหล่งต่างๆ

2. การฉีดการพึ่งพาที่เป็นอันตราย

คำนึงถึงการพึ่งพาที่ยอมรับอินพุตภายนอกโดยไม่มีการตรวจสอบที่เหมาะสม ผู้โจมตีอาจฉีดโค้ดหรือข้อมูลที่เป็นอันตรายผ่านการพึ่งพาที่ถูกบุกรุกได้ ทำความสะอาดอินพุตผู้ใช้ทั้งหมดและใช้กลไกการตรวจสอบความถูกต้องที่แข็งแกร่ง

3. การรั่วไหลของข้อมูลผ่านการพึ่งพา

ตรวจสอบให้แน่ใจว่าการพึ่งพาไม่ได้เปิดเผยข้อมูลที่ละเอียดอ่อนโดยไม่ได้ตั้งใจ ตรวจสอบโค้ดและการกำหนดค่าของการพึ่งพาของคุณเพื่อระบุช่องโหว่ในการรั่วไหลของข้อมูลที่อาจเกิดขึ้น

4. ความลับที่ฮาร์ดโค้ด

หลีกเลี่ยงการฮาร์ดโค้ดความลับ (API keys, รหัสผ่านฐานข้อมูล ฯลฯ) โดยตรงลงในโค้ดการพึ่งพาของคุณ ใช้ตัวแปรสภาพแวดล้อมหรือเครื่องมือการจัดการการกำหนดค่าที่ปลอดภัยเพื่อจัดเก็บและจัดการความลับ

            
import os
from fastapi import FastAPI, Depends

app = FastAPI()


def get_api_key():
    api_key = os.environ.get("API_KEY")
    if not api_key:
        raise ValueError("API_KEY environment variable not set.")
    return api_key

@app.get("/secure_endpoint/")
async def secure_endpoint(api_key: str = Depends(get_api_key)):
    # Use api_key for authentication/authorization
    return {"message": "Access granted"}

            

              
                Copy
              
            
          

การเพิ่มประสิทธิภาพประสิทธิภาพด้วยการฉีดการพึ่งพา

การฉีดการพึ่งพาสามารถส่งผลกระทบต่อประสิทธิภาพได้หากไม่ได้ใช้งานอย่างรอบคอบ นี่คือกลยุทธ์การเพิ่มประสิทธิภาพบางอย่าง:

1. ลดต้นทุนการสร้างการพึ่งพา

หลีกเลี่ยงการสร้างการพึ่งพาที่มีราคาแพงในทุกคำขอหากเป็นไปได้ หากการพึ่งพาไม่มีสถานะหรือสามารถแชร์ระหว่างคำขอได้ ให้พิจารณาใช้ขอบเขตซิงเกิลตันหรือแคชอินสแตนซ์การพึ่งพา

2. การเริ่มต้นแบบเกียจคร้าน

เริ่มต้นการพึ่งพาเมื่อจำเป็นเท่านั้น ซึ่งสามารถลดเวลาเริ่มต้นและการใช้หน่วยความจำ โดยเฉพาะอย่างยิ่งสำหรับแอปพลิเคชันที่มีการพึ่งพาจำนวนมาก

3. การแคชผลลัพธ์การพึ่งพา

แคชผลลัพธ์ของการคำนวณการพึ่งพาที่มีราคาแพง หากมีแนวโน้มที่จะนำผลลัพธ์กลับมาใช้ใหม่ ใช้กลไกการแคช (เช่น Redis, Memcached) เพื่อจัดเก็บและเรียกค้นผลลัพธ์การพึ่งพา

4. เพิ่มประสิทธิภาพกราฟการพึ่งพา

วิเคราะห์กราฟการพึ่งพาของคุณเพื่อระบุจุดคอขวดที่อาจเกิดขึ้น ทำให้โครงสร้างการพึ่งพาง่ายขึ้นและลดจำนวนการพึ่งพาให้เหลือน้อยที่สุดหากเป็นไปได้

5. การพึ่งพาแบบอะซิงโครนัสสำหรับการดำเนินการที่ถูกผูกไว้ I/O

ใช้การพึ่งพาแบบอะซิงโครนัสเมื่อดำเนินการ I/O แบบบล็อก เช่น การสอบถามฐานข้อมูลหรือการเรียก API ภายนอก สิ่งนี้ช่วยป้องกันการบล็อกเธรดหลักและปรับปรุงการตอบสนองของแอปพลิเคชันโดยรวม

แนวทางปฏิบัติที่ดีที่สุดสำหรับการฉีดการพึ่งพา FastAPI

• รักษาการพึ่งพาให้เรียบง่าย: ตั้งเป้าไปที่การพึ่งพาที่เล็กและเน้นที่ทำงานเดียว ซึ่งช่วยเพิ่มความสามารถในการอ่านได้ ความสามารถในการทดสอบ และการบำรุงรักษา
• ใช้คำแนะนำประเภท: ใช้คำแนะนำประเภทเพื่อกำหนดประเภทอินพุตและเอาต์พุตที่คาดหวังของการพึ่งพาอย่างชัดเจน ซึ่งช่วยเพิ่มความชัดเจนของโค้ดและช่วยให้ FastAPI ดำเนินการตรวจสอบประเภทแบบคงที่ได้
• เอกสารการพึ่งพา: จัดทำเอกสารวัตถุประสงค์และการใช้งานของการพึ่งพาทุกครั้ง ซึ่งช่วยให้นักพัฒนาคนอื่นๆ เข้าใจวิธีการใช้และบำรุงรักษาโค้ดของคุณ
• ทดสอบการพึ่งพาอย่างละเอียด: เขียนการทดสอบหน่วยสำหรับการพึ่งพาของคุณเพื่อให้แน่ใจว่าการพึ่งพามีพฤติกรรมตามที่คาดหวัง สิ่งนี้ช่วยป้องกันข้อบกพร่องและปรับปรุงความน่าเชื่อถือโดยรวมของแอปพลิเคชันของคุณ
• ใช้แบบแผนการตั้งชื่อที่สอดคล้องกัน: ใช้แบบแผนการตั้งชื่อที่สอดคล้องกันสำหรับการพึ่งพาของคุณเพื่อปรับปรุงความสามารถในการอ่านโค้ด
• หลีกเลี่ยงการพึ่งพาแบบวงกลม: การพึ่งพาแบบวงกลมอาจนำไปสู่โค้ดที่ซับซ้อนและยากต่อการแก้ไข ปรับโครงสร้างโค้ดของคุณเพื่อกำจัดการพึ่งพาแบบวงกลม
• พิจารณาคอนเทนเนอร์การฉีดการพึ่งพา (ไม่จำเป็น): แม้ว่าการฉีดการพึ่งพาในตัวของ FastAPI จะเพียงพอสำหรับกรณีส่วนใหญ่ ให้พิจารณาใช้คอนเทนเนอร์การฉีดการพึ่งพาโดยเฉพาะ (เช่น `inject`, `autowire`) สำหรับแอปพลิเคชันที่ซับซ้อนกว่า

บทสรุป

ระบบการฉีดการพึ่งพาของ FastAPI เป็นเครื่องมืออันทรงพลังที่ส่งเสริมความเป็นโมดูล ความสามารถในการทดสอบ และความสามารถในการนำกลับมาใช้ใหม่ ด้วยการเรียนรู้เทคนิคขั้นสูง เช่น การใช้คลาสเป็นส่วนประกอบ การแทนที่การพึ่งพา และการใช้ contextvars คุณสามารถสร้าง API ที่แข็งแกร่งและปรับขนาดได้ การทำความเข้าใจขอบเขตการพึ่งพาและวงจรชีวิตมีความสำคัญอย่างยิ่งต่อการจัดการทรัพยากรอย่างมีประสิทธิภาพ ให้ความสำคัญกับการทดสอบการพึ่งพาของคุณอย่างละเอียดเสมอเพื่อรับประกันความน่าเชื่อถือและความปลอดภัยของแอปพลิเคชันของคุณ ด้วยการปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดและพิจารณาถึงผลกระทบด้านความปลอดภัยและประสิทธิภาพที่อาจเกิดขึ้น คุณสามารถใช้ศักยภาพของระบบการฉีดการพึ่งพาของ FastAPI ได้อย่างเต็มที่